home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 February: Tool Chest / Dev.CD Feb 00 TC.toast / pc / what's new? / sample code / graphics 3d / setupgl / setupdsp.c < prev    next >
Encoding:
Text File  |  1999-12-18  |  26.6 KB  |  834 lines
  1. /*
  2.     File:        SetupDSp.c
  3.  
  4.     Contains:    Functions to enable building and destorying a DSp fullscreen context
  5.  
  6.     Written by:    Geoff Stahl (ggs)
  7.  
  8.     Copyright:    Copyright © 1999 Apple Computer, Inc., All Rights Reserved
  9.  
  10.     Change History (most recent first):
  11.  
  12.          <3>    12/18/99    ggs     Fixed err use before init
  13.          <2>    12/18/99    ggs     Fix headers
  14.          <1>    11/28/99    ggs     Initial add.  Split of just DSp handling functions.  Added total
  15.                                     device RAM checks, better step downs using actual supported
  16.                                     resolutions. Need to add user verify for contexts that require
  17.                                     it, integration of this in context step down, and a freq bit
  18.                                     field.
  19.          <1>    11/11/99    ggs     Initial Add
  20.  
  21.     Disclaimer:    IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
  22.                 ("Apple") in consideration of your agreement to the following terms, and your
  23.                 use, installation, modification or redistribution of this Apple software
  24.                 constitutes acceptance of these terms.  If you do not agree with these terms,
  25.                 please do not use, install, modify or redistribute this Apple software.
  26.  
  27.                 In consideration of your agreement to abide by the following terms, and subject
  28.                 to these terms, Apple grants you a personal, non-exclusive license, under Apple’s
  29.                 copyrights in this original Apple software (the "Apple Software"), to use,
  30.                 reproduce, modify and redistribute the Apple Software, with or without
  31.                 modifications, in source and/or binary forms; provided that if you redistribute
  32.                 the Apple Software in its entirety and without modifications, you must retain
  33.                 this notice and the following text and disclaimers in all such redistributions of
  34.                 the Apple Software.  Neither the name, trademarks, service marks or logos of
  35.                 Apple Computer, Inc. may be used to endorse or promote products derived from the
  36.                 Apple Software without specific prior written permission from Apple.  Except as
  37.                 expressly stated in this notice, no other rights or licenses, express or implied,
  38.                 are granted by Apple herein, including but not limited to any patent rights that
  39.                 may be infringed by your derivative works or by other works in which the Apple
  40.                 Software may be incorporated.
  41.  
  42.                 The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
  43.                 WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
  44.                 WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  45.                 PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
  46.                 COMBINATION WITH YOUR PRODUCTS.
  47.  
  48.                 IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
  49.                 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  50.                 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  51.                 ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
  52.                 OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
  53.                 (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
  54.                 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  55. */
  56.  
  57.  
  58. // Usage notes: 
  59. // kUseFades enables gamma fades for activates and deactivates
  60. #define kUseFades
  61.  
  62. //kUseRAMCheck enables estimated video card RAM checks
  63. #define kUseRAMCheck
  64.  
  65.  
  66. // system includes ----------------------------------------------------------
  67.  
  68. //#include <MacTypes.h>
  69. //#include <Menus.h>
  70. #include <fp.h>
  71.  
  72. //#include <stdio.h>
  73. #include <string.h>
  74.  
  75.  
  76. // project includes ---------------------------------------------------------
  77.  
  78. #include "Error Handler.h"
  79. #include "SetupDSp.h"
  80.  
  81. // globals (internal/private) -----------------------------------------------
  82.  
  83. enum 
  84. { 
  85.     kMaxNumRes = 64, // max number of resolution slots
  86.     kMaxRefreshFreq = 75 
  87. }; 
  88.  
  89. Boolean gDSpStarted = false;
  90. Boolean gNeedFade = false;
  91.  
  92. // prototypes (internal/private) --------------------------------------------
  93.  
  94. DSpContextReference * ReserveUnusedDevices (GDHandle hGD);
  95. OSStatus FreeUnusedDevices (GDHandle hGD, DSpContextReference ** ppContextRefUnused);
  96. void BuildResolutionList (GDHandle hGD, Point * pResList, UInt32 * pFreqList);
  97. OSStatus DoDeviceRAMCheck (pstructGLInfo pcontextInfo, Point * pResList, UInt32 * pFreqList, GLint depthSizeSupport);
  98. Boolean DoContextStepDown (pstructGLInfo pcontextInfo, DSpContextAttributes * pContextAttributes, Point * pResList, UInt32 * pFreqList);
  99.  
  100.  
  101. // functions (internal/private) ---------------------------------------------
  102.  
  103. // ReserveUnusedDevices
  104.  
  105. // reserves contexts on unused devices to vprevent their selection by DSp, returns list of these devices
  106.  
  107. DSpContextReference * ReserveUnusedDevices (GDHandle hGD)
  108. {
  109.     DSpContextAttributes theContextAttributes;
  110.     DSpContextReference * pContextRefUnused = NULL;
  111.     GDHandle hDevice = DMGetFirstScreenDevice (true); // check number of screens
  112.     OSStatus err = noErr;
  113.     DisplayIDType displayID = 0;
  114.     short numDevices = 0, indexDevice = 0;
  115.     
  116.     do
  117.     {
  118.         numDevices++;
  119.         hDevice = DMGetNextScreenDevice (hDevice, true);
  120.     }
  121.     while (hDevice);
  122.     numDevices--; // only count unused screens
  123.     if (numDevices)
  124.     {
  125.         pContextRefUnused = (DSpContextReference *) NewPtr ((long) sizeof (DSpContextReference) * numDevices);
  126.         hDevice = DMGetFirstScreenDevice (true); // check number of screens
  127.         do
  128.         {
  129.             if (hDevice != hGD)    // if this device is not the one the user chose
  130.             {
  131.                 if (noErr == DSpReportError (DMGetDisplayIDByGDevice (hDevice, &displayID, false)))
  132.                     if (noErr == DSpReportError (DSpGetFirstContext (displayID, &pContextRefUnused [indexDevice]))) // get a context and
  133.                         if (noErr == DSpReportError (DSpContext_GetAttributes (pContextRefUnused [indexDevice], &theContextAttributes))) // find attributes
  134.                             DSpReportError (DSpContext_Reserve (pContextRefUnused [indexDevice], &theContextAttributes)); // reserve it
  135.                 indexDevice++;
  136.             }
  137.             hDevice = DMGetNextScreenDevice (hDevice, true);
  138.         }
  139.         while (hDevice);
  140.     }
  141.     return pContextRefUnused;
  142. }
  143.  
  144. // --------------------------------------------------------------------------
  145.  
  146. // FreeUnusedDevices
  147.  
  148. // frees screen that were previously reserved to prevent selection
  149.  
  150. OSStatus FreeUnusedDevices (GDHandle hGD, DSpContextReference ** ppContextRefUnused)
  151. {
  152.     OSStatus err = noErr;
  153.     GDHandle hDevice = DMGetFirstScreenDevice (true); // check number of screens
  154.     short indexDevice = 0;
  155.  
  156.     do
  157.     {
  158.         if (hDevice != hGD)    // if this device is not the one the user chose
  159.         {
  160.             err = DSpContext_Release (*ppContextRefUnused [indexDevice]); // release it
  161.             DSpReportError (err);
  162.             indexDevice++;
  163.         }
  164.         hDevice = DMGetNextScreenDevice (hDevice, true);
  165.     }
  166.     while (hDevice);
  167.     
  168.     DisposePtr ((Ptr) *ppContextRefUnused);
  169.     *ppContextRefUnused = NULL;
  170.     return err;
  171. }
  172.  
  173. // --------------------------------------------------------------------------
  174.  
  175. // BuildResolutionList
  176.  
  177. // builds a list of supported resolutions and frequencies for GDevice
  178.  
  179. void BuildResolutionList (GDHandle hGD, Point * pResList, UInt32 * pFreqList)
  180. {
  181.     DSpContextAttributes theContextAttributes;
  182.     DSpContextReference currContext;
  183.     OSStatus err;
  184.     DisplayIDType displayID = 0;
  185.     short i;
  186.     
  187.     for (i = 0; i < kMaxNumRes; i++)    // clear resolution list
  188.     {
  189.         pResList [i].h = 0x7FFF;
  190.         pResList [i].v = 0x7FFF;
  191.         pFreqList [i] = 0;            // some context require certain frequencies find highest for each (not higher than 85
  192.     }
  193.  
  194.     err = DMGetDisplayIDByGDevice (hGD, &displayID, true);
  195.     if (noErr != err)
  196.         ReportErrorNum ("DMGetDisplayIDByGDevice error", err);
  197.     else
  198.     {
  199.         if (noErr == DSpReportError (DSpGetFirstContext (displayID, &currContext)))
  200.             do
  201.             {    
  202.                 // insertion sort into resolution list
  203.                 if (noErr == DSpReportError (DSpContext_GetAttributes (currContext, &theContextAttributes)))
  204.                 {
  205.                     Point pntTemp;
  206.                     Boolean fDone = false;
  207.                     short i = 0;
  208.                     while ((i < kMaxNumRes) && (!fDone))
  209.                     {
  210.                         if ((theContextAttributes.displayWidth == pResList [i].h) && (theContextAttributes.displayHeight == pResList [i].v)) //skip
  211.                         {
  212.                             if ((pFreqList [i] == 0) || ((theContextAttributes.frequency <= (kMaxRefreshFreq << 16)) && (theContextAttributes.frequency > pFreqList [i])))
  213.                                 pFreqList [i] = theContextAttributes.frequency;
  214.                             break;
  215.                         }
  216.                         if (theContextAttributes.displayWidth * theContextAttributes.displayHeight < pResList [i].h * pResList [i].v) //insert
  217.                         {
  218.                             pntTemp = pResList [i];
  219.                             pResList [i].h = theContextAttributes.displayWidth;
  220.                             pResList [i].v = theContextAttributes.displayHeight;
  221.                             pFreqList [i] = theContextAttributes.frequency;
  222.                             fDone = true;
  223.                         }
  224.                         i++;
  225.                     }
  226.                     // i points to next element to switch; finish array swaps (if 
  227.                     while ((i < kMaxNumRes) && (fDone))
  228.                     {
  229.                         Point pntSwitch = pResList [i];
  230.                         pResList [i++] = pntTemp;
  231.                         pntTemp = pntSwitch;
  232.                     }
  233.                 }
  234.                 err = DSpGetNextContext (currContext, &currContext);
  235.                 if (noErr != err)
  236.                 {
  237.                     if (kDSpContextNotFoundErr != err) 
  238.                         DSpReportError (err);
  239.                     currContext = 0;    // ensure we drop out
  240.                 }
  241.             } 
  242.             while (currContext);
  243.         else
  244.             ReportErrorNum ("DSpGetFirstContext error", err);
  245.     }    
  246.     // zeroize unused elements
  247.     for (i = 0; i < kMaxNumRes; i++)
  248.         if ((pResList [i].h == 0x7FFF) || (pResList [i].v == 0x7FFF))
  249.         {
  250.             pResList [i].h = 0;
  251.             pResList [i].v = 0;
  252.         }
  253. }
  254.  
  255. // --------------------------------------------------------------------------
  256.  
  257. // DoDeviceRAMCheck
  258.  
  259. // checks requested allocation against device RAM
  260. // Note: may modify pcontextInfo
  261. // this should be equal or less strigent than OpenGL actual allocation to avoid failing on valid drawables
  262.  
  263. OSStatus DoDeviceRAMCheck (pstructGLInfo pcontextInfo, Point * pResList, UInt32 * pFreqList, GLint depthSizeSupport)
  264. {
  265.     float frontBufferFactor = 1.0, backBufferFactor = 0.0; // amount of screen(front) or request(back) sized buffers required, in bytes
  266.     Point pntFrontBuffer; // size of front buffer that wil be allocated
  267.     short i, indexFrontBuffer; 
  268.     OSStatus err = noErr;
  269.  
  270.     // must take into account the entire front buffer, so figure out what screen resolution we are really going to use
  271.     // find front buffer for request
  272.     i = 0;
  273.     while (((pResList [i].h < pcontextInfo->width) || (pResList [i].v < pcontextInfo->height)) &&
  274.            ((pResList [i].h != 0) || (pResList [i].v != 0)) &&
  275.            (i < kMaxNumRes))
  276.         i++;
  277.     // save front buffer sizes
  278.     pntFrontBuffer.h = pResList [i].h;
  279.     pntFrontBuffer.v = pResList [i].v;
  280.     // if we have a valid frequnecy for the context set it (to ensure a good selection
  281.     pcontextInfo->freq = pFreqList [i] >> 16;
  282.     indexFrontBuffer = i;
  283.     
  284.     // front buffers required
  285.     if (16 == pcontextInfo->pixelDepth)
  286.         frontBufferFactor *= 2.0;
  287.     else if (32 == pcontextInfo->pixelDepth)
  288.         frontBufferFactor *= 4.0;
  289.         
  290.     // back buffers required    
  291.     backBufferFactor = 0.0;
  292.     i = 0;
  293.     while (64 > i)
  294.         if (AGL_DOUBLEBUFFER == pcontextInfo->aglAttributes[i++])
  295.         {
  296.             if (16 == pcontextInfo->pixelDepth)
  297.                 backBufferFactor = 2.0;
  298.             else if (32 == pcontextInfo->pixelDepth)
  299.                 backBufferFactor = 4.0;
  300.             break;
  301.         }
  302.     i = 0;
  303.     while (64 > i)
  304.         if (AGL_DEPTH_SIZE == pcontextInfo->aglAttributes[i++])
  305.         {
  306.             short requestDepth = pcontextInfo->aglAttributes[i];
  307.             GLint bit = 0x00000001;
  308.             short currDepth = 0, prevDepth = 0;
  309.             if (depthSizeSupport)
  310.             {
  311.                 do
  312.                 {
  313.                     if (bit & depthSizeSupport)    // if the card supports the depth
  314.                     {
  315.                         prevDepth = currDepth;
  316.                         switch (bit)
  317.                         {
  318.                             case AGL_1_BIT:
  319.                                 currDepth = 1;
  320.                                 break;
  321.                             case AGL_2_BIT:
  322.                                 currDepth = 2;
  323.                                 break;
  324.                             case AGL_3_BIT:
  325.                                 currDepth = 3;
  326.                                 break;
  327.                             case AGL_4_BIT:
  328.                                 currDepth = 4;
  329.                                 break;
  330.                             case AGL_5_BIT:
  331.                                 currDepth = 5;
  332.                                 break;
  333.                             case AGL_6_BIT:
  334.                                 currDepth = 6;
  335.                                 break;
  336.                             case AGL_8_BIT:
  337.                                 currDepth = 8;
  338.                                 break;
  339.                             case AGL_10_BIT:
  340.                                 currDepth = 10;
  341.                                 break;
  342.                             case AGL_12_BIT:
  343.                                 currDepth = 12;
  344.                                 break;
  345.                             case AGL_16_BIT:
  346.                                 currDepth = 16;
  347.                                 break;
  348.                             case AGL_24_BIT:
  349.                                 currDepth = 24;
  350.                                 break;
  351.                             case AGL_32_BIT:
  352.                                 currDepth = 32;
  353.                                 break;
  354.                             case AGL_48_BIT:
  355.                                 currDepth = 48;
  356.                                 break;
  357.                             case AGL_64_BIT:
  358.                                 currDepth = 64;
  359.                                 break;
  360.                             case AGL_96_BIT:
  361.                                 currDepth = 96;
  362.                                 break;
  363.                             case AGL_128_BIT:
  364.                                 currDepth = 128;
  365.                                 break;
  366.                         }
  367.                     }
  368.                     bit *= 2;
  369.                 } while (!((requestDepth > prevDepth) && (requestDepth <= currDepth)) && (bit < AGL_128_BIT + 1));
  370.             }
  371.             else // no card depth support info
  372.                 currDepth = requestDepth;  // we don't have card info thus assume we can support exact depth requested (may fail later but will always be equal or less stringent)
  373.             if ((AGL_128_BIT >= bit) && (0 != currDepth))
  374.                 backBufferFactor += (float) currDepth / 8.0;
  375.             break;
  376.         }
  377.         
  378.     // What we now have:
  379.     //  pcontextInfo->width, height: request width and height
  380.     //  pResList: sorted list of resolutions supported on this display
  381.     //  pntFrontBuffer : size of front buffer that will currently be allocated
  382.     //  indexFrontBuffer: position in array of current front buffer request
  383.     //  frontBufferFactor: number of screen resolution size buffers that will be needed
  384.     //  backBufferFactor: number of request size buffers that will be needed
  385.     
  386.     // find a context size that can support our texture requirements in the current total VRAM
  387.     if ((pcontextInfo->VRAM - pcontextInfo->textureRAM) < (pntFrontBuffer.h * pntFrontBuffer.v * frontBufferFactor + 
  388.                                                            pcontextInfo->width * pcontextInfo->height * backBufferFactor))
  389.     {
  390.         if (pcontextInfo->fDepthMust && pcontextInfo->fSizeMust)
  391.         {
  392.             // cannot accomdate request
  393.             ReportError ("Not enough total VRAM for drawable and textures");
  394.             return err;
  395.         }
  396.         else if (pcontextInfo->fSizeMust) // if we can adjust the size, try adjusting the 
  397.         {
  398.             // try 16 bit if must size is true
  399.             if ((pcontextInfo->pixelDepth > 16) &&
  400.                 (pcontextInfo->VRAM - pcontextInfo->textureRAM) > (pntFrontBuffer.h * pntFrontBuffer.v * frontBufferFactor / 2.0 + 
  401.                                                                       pcontextInfo->width * pcontextInfo->height * (backBufferFactor - 2.0)))
  402.                 pcontextInfo->pixelDepth = 16;
  403.             else
  404.             {
  405.                 // cannot accomdate request
  406.                 ReportError ("Not enough total VRAM for drawable and textures");
  407.                 return err;
  408.             }
  409.         }
  410.         else // can adjust size and might be able to adjust dopth
  411.         {    // make drawable fit
  412.             Boolean fFound = false;
  413.             // see if we can just adjust the pixel depth
  414.             if ((pcontextInfo->pixelDepth > 16) &&    // if we are requesting 32 bit
  415.                 (!pcontextInfo->fDepthMust) &&         // if we can adjust the pixel depth
  416.                 (pcontextInfo->VRAM - pcontextInfo->textureRAM) > (pntFrontBuffer.h * pntFrontBuffer.v * frontBufferFactor / 2.0 + 
  417.                                                                       pcontextInfo->width * pcontextInfo->height * (backBufferFactor - 2.0)))
  418.             {
  419.                 fFound = true;
  420.                 pcontextInfo->pixelDepth = 16;
  421.             }
  422.             else // pixel depth alone wont do it
  423.             {
  424.                 short i = indexFrontBuffer - 1;
  425.                 while (i >= 0)
  426.                 {
  427.                     //
  428.                     if ((pcontextInfo->VRAM - pcontextInfo->textureRAM) > (pResList [i].h * pResList [i].v * frontBufferFactor + 
  429.                                                                               pResList [i].h * pResList [i].v * backBufferFactor))
  430.                     {
  431.                         fFound = true;
  432.                         pcontextInfo->width = pResList [i].h;
  433.                         pcontextInfo->height = pResList [i].v;
  434.                         pcontextInfo->freq = pFreqList [i] >> 16;
  435.                         break;
  436.                     }
  437.                     else if ((pcontextInfo->pixelDepth > 16) &&    // if we are requesting 32 bit
  438.                              (!pcontextInfo->fDepthMust) &&     // if we can adjust the pixel depth
  439.                              (pcontextInfo->VRAM - pcontextInfo->textureRAM) > (pResList [i].h * pResList [i].v * frontBufferFactor / 2.0 + 
  440.                                                                                 pResList [i].h * pResList [i].v * (backBufferFactor - 2.0)))
  441.                     {
  442.                         fFound = true;
  443.                         pcontextInfo->width = pResList [i].h;
  444.                         pcontextInfo->height = pResList [i].v;
  445.                         pcontextInfo->freq = pFreqList [i] >> 16;
  446.                         pcontextInfo->pixelDepth = 16;
  447.                         break;
  448.                     }
  449.                     i--;
  450.                 }
  451.                 // we tried the smallest screen size and still need to use less VRAM, adjust backbuffer to what is available
  452.                 if ((!fFound) && (((pcontextInfo->VRAM - pcontextInfo->textureRAM) - pResList [0].h * pResList [0].v * frontBufferFactor) > 0))
  453.                 {
  454.                     float factor;
  455.                     fFound = true;
  456.                     factor = sqrt((float) (pcontextInfo->width * pcontextInfo->height * backBufferFactor) / 
  457.                                   (float) ((pcontextInfo->VRAM - pcontextInfo->textureRAM) - pResList [0].h * pResList [0].v * frontBufferFactor));
  458.                     pcontextInfo->width /= factor;
  459.                     pcontextInfo->height /= factor;
  460.                     pcontextInfo->freq = pFreqList [0] >> 16;
  461.                 }
  462.             }
  463.             if (!fFound)
  464.             {
  465.                 // cannot accomdate request
  466.                 ReportError ("Not enough total VRAM for drawable and textures");
  467.                 return err;
  468.             }
  469.  
  470.         }
  471.     }
  472.     return noErr;
  473. }
  474.  
  475. // --------------------------------------------------------------------------
  476.  
  477. // DoContextStepDown
  478.  
  479. // steps down through frequencies, depths and sizes to try to find a valid context
  480. // bounded by flags for SizeMust and DepthMust
  481. // Note: may modify pcontextInfo
  482.  
  483. Boolean DoContextStepDown (pstructGLInfo pcontextInfo, DSpContextAttributes * pContextAttributes, Point * pResList, UInt32 * pFreqList)
  484. {
  485.     // find current resolution
  486.     short i = 0; 
  487.     while (((pResList [i].h <= pContextAttributes->displayWidth) || (pResList [i].v <= pContextAttributes->displayHeight)) && 
  488.             ((pResList [i].h != 0) || (pResList [i].v != 0)) &&
  489.             (i < kMaxNumRes))
  490.         i++;
  491.     i--; // i points to index of current resolution
  492.     
  493.     if (pcontextInfo->fSizeMust) // adjust depth only
  494.     {
  495.         if (pcontextInfo->pixelDepth > 16)    // also try pixel depth step down
  496.         {
  497.             pContextAttributes->displayBestDepth = 16;
  498.             pContextAttributes->backBufferBestDepth = 16;
  499.         }
  500.         else
  501.             return false; // no more options to try
  502.     }
  503.     else if (pcontextInfo->fDepthMust) // adjust size only
  504.     {
  505.         if (i > 0)
  506.         {
  507.             i--; // i was pointing at current resolution, now it is pointing at new resolution to try
  508.             // set new resolution
  509.             pContextAttributes->displayWidth = pResList [i].h;
  510.             pContextAttributes->displayHeight = pResList [i].v;
  511.             pcontextInfo->freq = pFreqList [i] >> 16;
  512.         }
  513.         else
  514.             return false;
  515.     }
  516.     else // adjust size and depth
  517.     {
  518.         if (pContextAttributes->displayBestDepth > 16)
  519.         {
  520.             pContextAttributes->displayBestDepth = 16;
  521.             pContextAttributes->backBufferBestDepth = 16;
  522.         }
  523.         else if (i > 0)
  524.         {
  525.             i--; // i was pointing at current resolution, now it is pointing at new resolution to try
  526.             // reset pixel depth
  527.             pContextAttributes->displayBestDepth = pcontextInfo->pixelDepth;
  528.             pContextAttributes->backBufferBestDepth = pcontextInfo->pixelDepth;
  529.             // set new resolution
  530.             pContextAttributes->displayWidth = pResList [i].h;
  531.             pContextAttributes->displayHeight = pResList [i].v;
  532.             pcontextInfo->freq = pFreqList [i] >> 16;
  533.         }
  534.         else
  535.             return false;
  536.             
  537.     }
  538.     return true;
  539. }
  540.  
  541. #pragma mark -
  542. // functions (public) -------------------------------------------------------
  543.  
  544. // StartDSp
  545.  
  546. // handles starting up DrawSprocket
  547.  
  548. OSStatus StartDSp (void)
  549. {
  550.     OSStatus err = noErr;
  551.     
  552.     if (!gDSpStarted)
  553.     {
  554.         // check for DSp
  555.         if ((Ptr) kUnresolvedCFragSymbolAddress == (Ptr) DSpStartup) 
  556.         {
  557.             ReportError ("DSp not installed");
  558.             return noErr;
  559.         }    
  560.  
  561.         err = DSpReportError (DSpStartup()); // start DSp
  562.         if (noErr != err)
  563.             return err;
  564.         else
  565.             gDSpStarted = true;
  566.     }
  567.     return err;        
  568. }
  569.  
  570. // --------------------------------------------------------------------------
  571.  
  572. // ShutdownDSpContext
  573.  
  574. // shuts down DrawSprocket
  575.  
  576. void ShutdownDSp (void)
  577. {
  578.     if (gDSpStarted)
  579.     {
  580.         DSpShutdown ();
  581.         gDSpStarted = false;
  582.     }
  583. }
  584.  
  585. #pragma mark -
  586. // --------------------------------------------------------------------------
  587.  
  588. // BuildDSpContext
  589.  
  590. // contexInfo and tries to allocate the corresponding DSp context
  591.  
  592. // Inputs:     hGD: GDHandle to device to look at
  593. //            pcontextInfo: request and requirements for cotext and drawable
  594.  
  595. // Outputs: *pdspContext as allocated
  596. //            pcontextInfo:  allocated parameters
  597.  
  598. // if fail to allocate: pdspContext will be NULL
  599. // if error: will return error pdspContext will be NULL
  600.  
  601. OSStatus BuildDSpContext (DSpContextReference* pdspContext, GDHandle hGD, GLint depthSizeSupport, pstructGLInfo pcontextInfo)
  602. {
  603.     DSpContextAttributes theContextAttributes, foundAttributes;
  604.     DSpContextReference * pContextRefUnused;
  605.     UInt32 aFreqList [kMaxNumRes];
  606.     Point aResList [kMaxNumRes]; // list for resolution information
  607.     OSStatus err = noErr;
  608.     
  609.     *pdspContext = 0;
  610.  
  611.     if (!gDSpStarted)
  612.     {
  613.         // check for DSp
  614.         if ((Ptr) kUnresolvedCFragSymbolAddress == (Ptr) DSpStartup) 
  615.         {
  616.             ReportError ("DSp not installed");
  617.             return noErr;
  618.         }    
  619.  
  620.         err = DSpReportError (DSpStartup()); // start DSp
  621.         if (noErr != err)
  622.         {
  623.             return err;
  624.         }
  625.         else
  626.             gDSpStarted = true;
  627.     }        
  628.  
  629.     // reserve contexts on other screens to prevent their selection
  630.     pContextRefUnused = ReserveUnusedDevices (hGD);
  631.     
  632.     // build resolution list
  633.     BuildResolutionList (hGD, aResList, aFreqList);
  634.     
  635.     // handle default pixel depths
  636.     if (pcontextInfo->pixelDepth == 0)    // default
  637.     {
  638.         pcontextInfo->pixelDepth = (**(**hGD).gdPMap).pixelSize;
  639.         if (pcontextInfo->pixelDepth < 16)
  640.             pcontextInfo->pixelDepth = 16;
  641.     }
  642.  
  643. #ifdef kUseRAMCheck
  644.     if (noErr != DoDeviceRAMCheck (pcontextInfo, aResList, aFreqList, depthSizeSupport))
  645.         return err;
  646. #endif // kUseRAMCheck
  647.  
  648.     // Note: DSp < 1.7.3 REQUIRES the back buffer attributes even if only one buffer is required
  649.     memset(&theContextAttributes, 0, sizeof (DSpContextAttributes));
  650.     theContextAttributes.displayWidth                = pcontextInfo->width;
  651.     theContextAttributes.displayHeight                = pcontextInfo->height;
  652.     theContextAttributes.displayBestDepth            = pcontextInfo->pixelDepth;
  653.     theContextAttributes.backBufferBestDepth        = pcontextInfo->pixelDepth;
  654.     do
  655.     {    
  656.         theContextAttributes.frequency                = pcontextInfo->freq * 0x10000;
  657.         theContextAttributes.colorNeeds                = kDSpColorNeeds_Require;
  658.         theContextAttributes.displayDepthMask        = kDSpDepthMask_All;
  659.         theContextAttributes.backBufferDepthMask    = kDSpDepthMask_All;
  660.         theContextAttributes.pageCount                = 1; // only the front buffer is needed
  661.         err = DSpFindBestContext(&theContextAttributes, pdspContext);
  662.         if (noErr != err)    // if we had any errors, reset for next try
  663.             if (!DoContextStepDown (pcontextInfo, &theContextAttributes, aResList, aFreqList))
  664.                 break; // have run out of options
  665.     } while (err == kDSpContextNotFoundErr);
  666.  
  667.     // check find best context errors
  668.     if (kDSpContextNotFoundErr == err)
  669.     {    
  670.         *pdspContext = 0;
  671.         return noErr;
  672.     }
  673.     else if (noErr != err)
  674.     {
  675.         DSpReportError (err);
  676.         *pdspContext = 0;
  677.         return err;
  678.     }
  679.     
  680.     err = DSpReportError (DSpContext_GetAttributes (*pdspContext, &foundAttributes));
  681.     if (noErr != err)
  682.     {
  683.         *pdspContext = 0;
  684.         return err;
  685.     }
  686.     // reset width and height to full screen and handle our own centering
  687.     // HWA will not correctly center less than full screen size contexts
  688.     theContextAttributes.displayWidth         = foundAttributes.displayWidth;
  689.     theContextAttributes.displayHeight         = foundAttributes.displayHeight;
  690.     theContextAttributes.pageCount            = 1; // only the front buffer is needed
  691.     theContextAttributes.contextOptions        = 0 | kDSpContextOption_DontSyncVBL; // no page flipping and no VBL sync needed
  692.  
  693.     err = DSpReportError (DSpContext_Reserve(*pdspContext, &theContextAttributes )); // reserve our context
  694.     if (noErr != err)
  695.     {
  696.         *pdspContext = 0;
  697.         return err;
  698.     }
  699.     if (gNeedFade == true)
  700.     {
  701.         DSpReportError (DSpContext_CustomFadeGammaOut (NULL, NULL, 5));
  702.         gNeedFade = false;
  703.     }
  704.     err = DSpReportError (DSpContext_SetState (*pdspContext, kDSpContextState_Active)); // activate our context
  705.     if (noErr != err)
  706.     {
  707.         DSpContext_Release (*pdspContext);
  708.         *pdspContext = 0;
  709.         return err;
  710.     }
  711.  
  712.     FreeUnusedDevices (hGD, &pContextRefUnused);
  713.     
  714.     if (!pcontextInfo->fSizeMust)    // if we got whatever was available
  715.     {
  716.         // reset inputs to what was allocated (constrain aspect ratio)
  717.         // unless we ask for smaller, then leave the same
  718.         if ((pcontextInfo->width > foundAttributes.displayWidth) || (pcontextInfo->height > foundAttributes.displayHeight))
  719.         {
  720.             float hFactor = (float) pcontextInfo->width / (float) foundAttributes.displayWidth;
  721.             float vFactor = (float) pcontextInfo->height / (float) foundAttributes.displayHeight;
  722.             if (hFactor > vFactor)
  723.             {
  724.                 pcontextInfo->width = foundAttributes.displayWidth;
  725.                 pcontextInfo->height /= hFactor;    
  726.             }
  727.             else
  728.             {
  729.                 pcontextInfo->height = foundAttributes.displayHeight;
  730.                 pcontextInfo->width /= vFactor;    
  731.             }
  732.         }
  733.     }
  734.     // else still use inputs to allocate drawable
  735.     
  736.     pcontextInfo->freq = foundAttributes.frequency / 0x10000;
  737.     pcontextInfo->pixelDepth = foundAttributes.displayBestDepth;
  738.  
  739.     return noErr;
  740. }
  741.  
  742. //-----------------------------------------------------------------------------------------------------------------------
  743.  
  744. // Deactivates and dumps context
  745.  
  746. void DestroyDSpContext (DSpContextReference* pdspContext)
  747. {
  748.     if (gDSpStarted)
  749.     {
  750.         if (*pdspContext)
  751.         {
  752.             DSpContext_SetState(*pdspContext, kDSpContextState_Inactive );
  753.             DSpReportError (DSpContext_CustomFadeGammaIn (NULL, NULL, 5));
  754.             DSpContext_Release (*pdspContext);
  755.             *pdspContext = NULL;
  756.         }
  757.     }
  758. }
  759.  
  760.  
  761. #pragma mark -
  762. //-----------------------------------------------------------------------------------------------------------------------
  763.  
  764. OSStatus DSpContext_CustomFadeGammaIn (DSpContextReference inContext, const RGBColor *fadeColor,  long fadeTicks ) 
  765. {
  766.     RGBColor inZeroIntensityColor;
  767.     OSStatus err = noErr;
  768.     long currTick;
  769.     UInt16 step = 800 / fadeTicks;
  770.     short x, percent = 0;
  771.  
  772. #ifdef kUseFades
  773.     if (fadeTicks == 0)
  774.         fadeTicks = 1;
  775.     if (fadeColor == NULL) 
  776.     {
  777.         inZeroIntensityColor.red = 0x0000;
  778.         inZeroIntensityColor.green = 0x0000;
  779.         inZeroIntensityColor.blue = 0x0000;
  780.     }
  781.     else 
  782.         inZeroIntensityColor = *fadeColor;
  783.     currTick = TickCount ();
  784.     for (x = 1; x <= fadeTicks; x++) 
  785.     {
  786.         percent =  step * x >> 3;
  787.         err = DSpContext_FadeGamma(inContext, percent, &inZeroIntensityColor);
  788.         if (err != noErr) 
  789.             break;
  790.         while (currTick >= TickCount ()) 
  791.             SystemTask ();
  792.         currTick = TickCount ();
  793.     }
  794.     if (err == noErr)
  795.         err = DSpContext_FadeGamma(inContext, 100, &inZeroIntensityColor);
  796. #endif // kUseFades
  797.     return err;
  798. }
  799.  
  800. //-----------------------------------------------------------------------------------------------------------------------
  801.  
  802. OSStatus DSpContext_CustomFadeGammaOut (DSpContextReference inContext, const RGBColor *fadeColor, long fadeTicks ) 
  803. {
  804.     RGBColor inZeroIntensityColor;
  805.     OSStatus err = noErr;
  806.     long currTick;
  807.     UInt16 step = 800 / fadeTicks;
  808.     short x, percent = 0;
  809.  
  810. #ifdef kUseFades
  811.     if (fadeTicks == 0)
  812.         fadeTicks = 1;                                // ensure we do not have zero fade time
  813.     if (fadeColor == NULL) 
  814.     {
  815.         inZeroIntensityColor.red = 0x0000;
  816.         inZeroIntensityColor.green = 0x0000;
  817.         inZeroIntensityColor.blue = 0x0000;
  818.     }
  819.     else 
  820.         inZeroIntensityColor = *fadeColor;
  821.     currTick = TickCount ();
  822.     for (x = fadeTicks - 1; x >= 0; x--) 
  823.     {
  824.         percent =  step * x >> 3;
  825.         err = DSpContext_FadeGamma(inContext, percent, &inZeroIntensityColor);
  826.         if (err != noErr) 
  827.             break;
  828.         while (currTick >= TickCount ()) 
  829.             SystemTask ();
  830.         currTick = TickCount ();
  831.     }
  832. #endif // kUseFades
  833.     return err;
  834. }